<nodeFunc>

	A NodeFunc is a function which executes 1 node in a network,
	and affects at most that node and its child nodes.
	Child nodes may be in any constant quantity of arrays in the node.
	For example, some type of node may have 7 arrays of child nodes, each a different size and purpose.
	
	While a netwokr executes, the quantity of nodes and childs of nodes do not change.
	That can happen between executions. Each execution must return quickly.
	A network has exactly 1 NodeFunc. Each execution of the network executes that NodeFunc
	on the node with the highest sort value.
	The sort value of a node is always the first float in a float array in that node.
	That array is always the first array in that node, and it can have any constant size at least 1.
	
	The first array in a network is always an array of node and contains all the nodes in the network.
	
	For the same network, quantity of arrays in the network (netArraysSize) is constant,
	and all nodes have the same quantity of arrays (nodeArraysSize) as eachother.
	Arrays in the network and arrays in the current node (that the NodeFunc is executing on)
	are in the same namespace.
	That namespace could be represented as numbers 0 to (netArrays.size+nodeArrays.size)-1.
	
	The sort value of a node is at netArraysSize.0,
	which means index 0 in the array at index netArraysSize.
	
	If array 5 in all nodes is a list of child nodes, and array 3 in all nodes is a constant size float array,
	then how to write this?: the float at index 7 of the current child node of the current node.
	Does this work?: (netArraysSize+5).(netArraysSize+3).7
	
	<question>
		Should some indexs in the network/node namespace be iteration vars?
		For example, in a neural-like node with X^Z floats, X childs, and Z=3 is constant.
		how to define 3 iteration vars to use while iterating over X^3 floats?
		<question>
			Could those 3 vars be child nodes, and could arrays in them be used during this iteration?
			That would probably break the rule of not changing the contents of any node array during execution.
		</question>
		Before X^3 exists, there must be an array size 3.
		To use X*3 with X^3, need an interation var that is 1 of the 3 values,
		but this question is about using 3 vars at once.
		<question>
			How to use X^2 (X^Y) and X^3 (X^Z) together?
			Y may be defined as a constant size or as size with some minimum M and maximum Z.
			If Y is variable size (with maximum Z), how would variables be mapped from Z to Y?
			By design, that is not allowed, because Y and Z can be different sizes and they are bing compared linearly.
			But maybe the design should be changed so Y can be mapped to one of the ends of Z,
			with a choice of aligning on index 0 or in the last index.
			<question>
				Does giving the choice of alignment add any flexibility?
				If A<=C and B<=C, then for some values of A and B,
				aligning them at opposite ends covers more values.
				Always aligning at 0 is much simpler.
				<question>
					Should array size limits be definable in terms of PLUS?
					For example, A+B=C, or A+B<=C.
					That adds a lot of complication. Its probably easy to add it later.
				</question>
			</question>
		</question>
	</question>
	
	For now, do not allow PLUS as an array size operator, but the syntax should be flexible enough
	to allow PLUS when I add it later.
	
	<question>
		Will the factorial operator (maybe "!") ever be used for array size?
	</question>
	
	<question>
		Will the symmetricEdgeIncludingSelf (N*(N+1)/2) operator ever be used for array size?
		symmetricEdgeNotIncludingSelf (N*(N-1)/2)?
		Nonsymmetric edge would be N^2.
	</question>
	
	<question>
		Should the MINUS operator ever be used for array size?
	</question>

	<question>
		How to use X^Y and X^Z together, where Y=2 and Z=3 are constants?
		Examples...
		Iterate index k over X^Z.
		Technically, the 3 vars can be defined as some combinations of k^(1/3) and k^(2/3) and k^(3/3),
		but that is not efficient. It could be written those ways, but theres probably a simpler way.
		k = Z.0*X^0 + Z.1*X^1 + Z.2*X^2.
		<question>
			Should the syntax include Z[2] and Z.2? Are there 2 different things for those to mean?
			There should be separate iteration methods for MULTIPLY and POWER.
			MULTIPLY has 1 index and POWER has multiple indexs.
			<question>
				Should there be int arrays whose contents change during iteration?
				For example, if iterating over X^D, all ints in an array size D would change all the ints each iteration.
				That would be slow if D was big, but since D is the exponent, it will not be big.
			</question>
		</question>
		Iterating index k over X^Z, Z[0] and Z[1] and Z[2] should be parts of something, or Z.0 and Z.1 and Z.2?
		Iterating t over B*C^D, each iteration should be able to use index [B] (or just B?), C[D[0]], C[D[1]]...
		That doesnt look correct.
		
	</question>
	
	arrayIterationOp "each" has 1 iterationVar.
	arrayIterationOp "all" has variable quantity of iterationVars, the quantity of array size.
	arrayIterationOp "*" has 1 or 2 iterationVars.
	arrayIterationOp "^" has variable quantity of iterationVars, the quantity of the exponent.
	arrayIterationOp "symmetricEdgeIncludingSelf" has 1 or 2 iterationVars.
	
	It would simplify things a lot to use the same syntax if there is 1 or more iterationVars,
	and to have that quantity of iterationVars in one of the array positions (can be an Integer, not array).
	
	Example:
	X is constant size 5, Y is size X. H is Integer 1.
	Iterating over "each" Y maps the current double or node in Y to the first (and only) index in H.
	That should not be written as H. It should be written as H.0 or H[0]. Which one?
	
	Example:
	A neural-like node with X^Z floats, X childs, and Z=3 is constant.
	Use it with a neural-like node with X^Y floats, X childs, and Y=2 is constant.
	Iterate over X^Z maps to 3 index of Z and at each of those 3 is an index between 0 and X-1.
	Map X^Y to the first 2 index of Z.
	<question>
		Is that harder than using the second index then the first?
	</question>
	<unfinishedExample>
		XITER is Integer 1.
		"Y + Z + X^YY + XX^ZZ" --> "Y + Z + X^YY + XX^ZZ"
	</unfinishedExample>
	
	<question>
		Should each array, if its definition includes a maximum size M, be mapped to some subrange of M?
		That way, it would not have to be defined in the iteration codes.
		<question>
			Do I ever need to map a nonadjacent subset of indexs?
		</question>
		<question>
			How to map the "each" arrayIterationOp, because its not aligned on either end?
			Should "each" in X be written as X^H[0], where H is Integer 1?
		</question>
	</question>

</nodeFunc>